名域 ts {
    // WARNING: The script `configureNightly.ts` uses a regexp to parse out these values.
    // If changing the 文本 in this section, be sure to test `configureNightly` too.
    导出 常量 主版本号 = '0.1';
    /** The version of the TypeScript compiler release */
    导出 常量 版本号 = `${主版本号}.0`;
}

/* @internal */
名域 ts {
    导出 常量 空数组: 不及[] = [] 转为 不及[];

    导出 函数 关闭文件监控(监控者: 文件监控_) {
        监控者.close();
    }

    /** Create a new map. If a 模板 object is provided, the map will copy entries from it. */
    导出 函数 创建词典<T>(): 词典_<T> {
        返回 新建 映射_<文字, T>();
    }

    导出 类型 词典_<T> =  映射_<文字, T>

    导出 函数 创建词典从模板<T>(模板?: 词典族_<T>): 词典_<T> {
        常量 map: 词典_<T> = 新建 映射_<文字, T>();

        // Copies keys/values from 模板. Note that for..in will not throw if
        // 模板 is 未定, and instead will just exit the loop.
        循环 (常量 key 位于 模板) {
            如果 (hasOwnProperty.调用(模板, key)) {
                map.设置(key, 模板[key]);
            }
        }

        返回 map;
    }


    导出 函数 长度(数组: 只读数组_<任意>) {
        返回 数组 ? 数组.长度 : 0;
    }

    /**
     * Iterates through '数组' by index and performs the callback on each 元素 of 数组 until the callback
     * returns a truthy value, then returns that value.
     * If no such value is found, the callback is applied to each 元素 of 数组 and 未定 is returned.
     */
    导出 函数 循环执行<T, U>(数组: 只读数组_<T> | 未定, cb: (元素: T, index: 数字) => U | 未定): U | 未定 {
        如果 (数组) {
            循环 (变量 i = 0; i < 数组.长度; i++) {
                常量 结果 = cb(数组[i], i);
                如果 (结果) {
                    返回 结果;
                }
            }
        }
        返回 未定;
    }

    /** Like `forEach`, but suitable for use with numbers and strings (which may be falsy). */
    导出 函数 firstDefined<T, U>(数组: 只读数组_<T> | 未定, cb: (元素: T, index: 数字) => U | 未定): U | 未定 {
        如果 (数组 === 未定) {
            返回 未定;
        }

        循环 (变量 i = 0; i < 数组.长度; i++) {
            常量 结果 = cb(数组[i], i);
            如果 (结果 !== 未定) {
                返回 结果;
            }
        }
        返回 未定;
    }

    导出 函数 firstDefinedIterator<T, U>(iter: 迭代器_<T>, cb: (元素: T) => U | 未定): U | 未定 {
        判断 (为真) {
            常量 { value, done } = iter.next();
            如果 (done) {
                返回 未定;
            }
            常量 结果 = cb(value);
            如果 (结果 !== 未定) {
                返回 结果;
            }
        }
    }

    导出 函数 zipWith<T, U, V>(arrayA: 只读数组_<T>, arrayB: 只读数组_<U>, cb: (a: T, b: U, index: 数字) => V): V[] {
        常量 结果: V[] = [];
        调试_.assertEqual(arrayA.长度, arrayB.长度);
        循环 (变量 i = 0; i < arrayA.长度; i++) {
            结果.压入(cb(arrayA[i], arrayB[i], i));
        }
        返回 结果;
    }

    导出 函数 zipToIterator<T, U>(arrayA: 只读数组_<T>, arrayB: 只读数组_<U>): 迭代器_<[T, U]> {
        调试_.assertEqual(arrayA.长度, arrayB.长度);
        变量 i = 0;
        返回 {
            next() {
                如果 (i === arrayA.长度) {
                    返回 { value: 未定 转为 不及, done: 为真 };
                }
                i++;
                返回 { value: [arrayA[i - 1], arrayB[i - 1]], done: 为假 };
            }
        };
    }

    导出 函数 压缩转为词典<T>(keys: 只读数组_<文字>, values: 只读数组_<T>): 词典_<T> {
        调试_.断言(keys.长度 === values.长度);
        常量 map = 创建词典<T>();
        循环 (变量 i = 0; i < keys.长度; ++i) {
            map.设置(keys[i], values[i]);
        }
        返回 map;
    }

    /**
     * Iterates through `数组` by index and performs the callback on each 元素 of 数组 until the callback
     * returns a falsey value, then returns false.
     * If no such value is found, the callback is applied to each 元素 of 数组 and `true` is returned.
     */
    导出 函数 every<T>(数组: 只读数组_<T>, cb: (元素: T, index: 数字) => 真假): 真假 {
        如果 (数组) {
            循环 (变量 i = 0; i < 数组.长度; i++) {
                如果 (!cb(数组[i], i)) {
                    返回 为假;
                }
            }
        }

        返回 为真;
    }

    /** Works like Array.prototype.find, returning `未定` if no 元素 satisfying the predicate is found. */
    导出 函数 查找<T, U 扩展 T>(数组: 只读数组_<T>, predicate: (元素: T, index: 数字) => 元素 作为 U): U | 未定;
    导出 函数 查找<T>(数组: 只读数组_<T>, predicate: (元素: T, index: 数字) => 真假): T | 未定;
    导出 函数 查找<T>(数组: 只读数组_<T>, predicate: (元素: T, index: 数字) => 真假): T | 未定 {
        循环 (变量 i = 0; i < 数组.长度; i++) {
            常量 value = 数组[i];
            如果 (predicate(value, i)) {
                返回 value;
            }
        }
        返回 未定;
    }

    导出 函数 findLast<T, U 扩展 T>(数组: 只读数组_<T>, predicate: (元素: T, index: 数字) => 元素 作为 U): U | 未定;
    导出 函数 findLast<T>(数组: 只读数组_<T>, predicate: (元素: T, index: 数字) => 真假): T | 未定;
    导出 函数 findLast<T>(数组: 只读数组_<T>, predicate: (元素: T, index: 数字) => 真假): T | 未定 {
        循环 (变量 i = 数组.长度 - 1; i >= 0; i--) {
            常量 value = 数组[i];
            如果 (predicate(value, i)) {
                返回 value;
            }
        }
        返回 未定;
    }

    /** Works like Array.prototype.findIndex, returning `-1` if no 元素 satisfying the predicate is found. */
    导出 函数 findIndex<T>(数组: 只读数组_<T>, predicate: (元素: T, index: 数字) => 真假): 数字 {
        循环 (变量 i = 0; i < 数组.长度; i++) {
            如果 (predicate(数组[i], i)) {
                返回 i;
            }
        }
        返回 -1;
    }

    /**
     * Returns the 首个 truthy 结果 of `callback`, or else fails.
     * This is like `forEach`, but never returns 未定.
     */
    导出 函数 findMap<T, U>(数组: 只读数组_<T>, cb: (元素: T, index: 数字) => U | 未定): U | 未定{
        循环 (变量 i = 0; i < 数组.长度; i++) {
            常量 结果 = cb(数组[i], i);
            如果 (结果) {
                返回 结果;
            }
        }
        调试_.失败();
    }

    导出 函数 包含<T>(数组: 只读数组_<T> | 未定, value: T, equalityComparer: 相等比较器_<T> = 相等值): 真假 {
        如果 (数组) {
            循环 (常量 v 属于 数组) {
                如果 (equalityComparer(v, value)) {
                    返回 为真;
                }
            }
        }
        返回 为假;
    }

    导出 函数 arraysEqual<T>(a: 只读数组_<T>, b: 只读数组_<T>, equalityComparer: 相等比较器_<T> = 相等值): 真假 {
        返回 a.长度 === b.长度 && a.每个((x, i) => equalityComparer(x, b[i]));
    }

    导出 函数 indexOfAnyCharCode(文本: 文字, charCodes: 只读数组_<数字>, 开始?: 数字): 数字 {
        循环 (变量 i = 开始 || 0; i < 文本.长度; i++) {
            如果 (包含(charCodes, 文本.字符代码在(i))) {
                返回 i;
            }
        }
        返回 -1;
    }

    导出 函数 countWhere<T>(数组: 只读数组_<T>, predicate: (x: T, i: 数字) => 真假): 数字 {
        变量 count = 0;
        如果 (数组) {
            循环 (变量 i = 0; i < 数组.长度; i++) {
                常量 v = 数组[i];
                如果 (predicate(v, i)) {
                    count++;
                }
            }
        }
        返回 count;
    }

    /**
     * Filters an 数组 by a predicate function. Returns the same 数组 instance if the predicate is
     * true for all 元素组, otherwise returns a new 数组 instance containing the filtered subset.
     */
    导出 函数 过滤器<T, U 扩展 T>(数组: T[], f: (x: T) => x 作为 U): U[];
    导出 函数 过滤器<T>(数组: T[], f: (x: T) => 真假): T[];
    导出 函数 过滤器<T, U 扩展 T>(数组: 只读数组_<T>, f: (x: T) => x 作为 U): 只读数组_<U>;
    导出 函数 过滤器<T, U 扩展 T>(数组: 只读数组_<T>, f: (x: T) => 真假): 只读数组_<T>;
    导出 函数 过滤器<T>(数组: T[], f: (x: T) => 真假): T[] {
        如果 (数组) {
            常量 len = 数组.长度;
            变量 i = 0;
            判断 (i < len && f(数组[i])) i++;
            如果 (i < len) {
                常量 结果 = 数组.分切(0, i);
                i++;
                判断 (i < len) {
                    常量 item = 数组[i];
                    如果 (f(item)) {
                        结果.压入(item);
                    }
                    i++;
                }
                返回 结果;
            }
        }
        返回 数组;
    }

    导出 函数 过滤多维<T>(数组: T[], f: (x: T, i: 数字, 数组: T[]) => 真假): 无值 {
        变量 outIndex = 0;
        循环 (变量 i = 0; i < 数组.长度; i++) {
            如果 (f(数组[i], i, 数组)) {
                数组[outIndex] = 数组[i];
                outIndex++;
            }
        }
        数组.长度 = outIndex;
    }

    导出 函数 clear(数组: {}[]): 无值 {
        数组.长度 = 0;
    }

    导出 函数 词典<T, U>(数组: 只读数组_<T>, f: (x: T, i: 数字) => U): U[] {
        变量 结果: U[];
        如果 (数组) {
            结果 = [];
            循环 (变量 i = 0; i < 数组.长度; i++) {
                结果.压入(f(数组[i], i));
            }
        }
        返回 结果!;
    }


    导出 函数 mapIterator<T, U>(iter: 迭代器_<T>, mapFn: (x: T) => U): 迭代器_<U> {
        返回 {
            next() {
                常量 iterRes = iter.next();
                返回 iterRes.done ? iterRes 转为 任意  转为 迭代器结果_<U>: { value: mapFn(iterRes.value), done: 为假 };
            }
        };
    }

    // Maps from T to T and avoids allocation if all 元素组 map to themselves
    导出 函数 sameMap<T>(数组: T[], f: (x: T, i: 数字) => T): T[];
    导出 函数 sameMap<T>(数组: 只读数组_<T>, f: (x: T, i: 数字) => T): 只读数组_<T>;
    导出 函数 sameMap<T>(数组: T[], f: (x: T, i: 数字) => T): T[] {
        如果 (数组) {
            循环 (变量 i = 0; i < 数组.长度; i++) {
                常量 item = 数组[i];
                常量 mapped = f(item, i);
                如果 (item !== mapped) {
                    常量 结果 = 数组.分切(0, i);
                    结果.压入(mapped);
                    循环 (i++; i < 数组.长度; i++) {
                        结果.压入(f(数组[i], i));
                    }
                    返回 结果;
                }
            }
        }
        返回 数组;
    }

    /**
     * Flattens an 数组 containing a mix of 数组 or non-数组 元素组.
     *
     * @param 数组 The 数组 to flatten.
     */
    导出 函数 扁平化<T>(数组: 只读数组_<T | 只读数组_<T>>): T[] {
        变量 结果: T[];
        如果 (数组) {
            结果 = [];
            循环 (常量 v 属于 数组) {
                如果 (v) {
                    如果 (是数组(v)) {
                        添加范围(结果, v);
                    }
                    否则 {
                        结果.压入(v);
                    }
                }
            }
        }

        返回 结果!;
    }

    /**
     * Maps an 数组. If the mapped value is an 数组, it is spread into the 结果.
     *
     * @param 数组 The 数组 to map.
     * @param mapfn The callback used to map the 结果 into one or more values.
     */
    导出 函数 扁平词典<T, U>(数组: 只读数组_<T> | 未定, mapfn: (x: T, i: 数字) => U | 只读数组_<U> | 未定): U[] {
        变量 结果: U[];
        如果 (数组) {
            结果 = [];
            循环 (变量 i = 0; i < 数组.长度; i++) {
                常量 v = mapfn(数组[i], i);
                如果 (v) {
                    如果 (是数组(v)) {
                        添加范围(结果, v);
                    }
                    否则 {
                        结果.压入(v);
                    }
                }
            }
        }
        返回 结果!;
    }

    导出 函数 flatMapIterator<T, U>(iter: 迭代器_<T>, mapfn: (x: T) => U[] | 迭代器_<U> | 未定): 迭代器_<U> {
        常量 首个 = iter.next();
        如果 (首个.done) {
            返回 emptyIterator;
        }
        变量 currentIter = getIterator(首个.value);
        返回 {
            next() {
                判断 (为真) {
                    常量 currentRes = currentIter.next();
                    如果 (!currentRes.done) {
                        返回 currentRes;
                    }
                    常量 iterRes = iter.next();
                    如果 (iterRes.done) {
                        返回 iterRes 转为 任意 转为 迭代器结果_<U>;
                    }
                    currentIter = getIterator(iterRes.value);
                }
            },
        };

        函数 getIterator(x: T): 迭代器_<U> {
            常量 res = mapfn(x);
            返回 res === 未定 ? emptyIterator : 是数组(res) ? arrayIterator(res) : res;
        }
    }

    /**
     * Maps an 数组. If the mapped value is an 数组, it is spread into the 结果.
     * Avoids allocation if all 元素组 map to themselves.
     *
     * @param 数组 The 数组 to map.
     * @param mapfn The callback used to map the 结果 into one or more values.
     */
    导出 函数 sameFlatMap<T>(数组: T[], mapfn: (x: T, i: 数字) => T | 只读数组_<T>): T[];
    导出 函数 sameFlatMap<T>(数组: 只读数组_<T>, mapfn: (x: T, i: 数字) => T | 只读数组_<T>): 只读数组_<T>;
    导出 函数 sameFlatMap<T>(数组: T[], mapfn: (x: T, i: 数字) => T | T[]): T[] {
        变量 结果: T[];
        如果 (数组) {
            循环 (变量 i = 0; i < 数组.长度; i++) {
                常量 item = 数组[i];
                常量 mapped = mapfn(item, i);
                如果 (结果! || item !== mapped || 是数组(mapped)) {
                    如果 (!结果!) {
                        结果 = 数组.分切(0, i);
                    }
                    如果 (是数组(mapped)) {
                        添加范围(结果, mapped);
                    }
                    否则 {
                        结果!.压入(mapped);
                    }
                }
            }
        }
        返回 结果! || 数组;
    }

    导出 函数 mapAllOrFail<T, U>(数组: 只读数组_<T>, mapFn: (x: T, i: 数字) => U | 未定): U[] | 未定 {
        常量 结果: U[] = [];
        循环 (变量 i = 0; i < 数组.长度; i++) {
            常量 mapped = mapFn(数组[i], i);
            如果 (mapped === 未定) {
                返回 未定;
            }
            结果.压入(mapped);
        }
        返回 结果;
    }

    导出 函数 mapDefined<T, U>(数组: 只读数组_<T> | 未定, mapFn: (x: T, i: 数字) => U | 未定): U[] {
        常量 结果: U[] = [];
        如果 (数组) {
            循环 (变量 i = 0; i < 数组.长度; i++) {
                常量 mapped = mapFn(数组[i], i);
                如果 (mapped !== 未定) {
                    结果.压入(mapped);
                }
            }
        }
        返回 结果;
    }

    导出 函数 词典定义的迭代器<T, U>(iter: 迭代器_<T>, mapFn: (x: T) => U | 未定): 迭代器_<U> {
        返回 {
            next() {
                判断 (为真) {
                    常量 res = iter.next();
                    如果 (res.done) {
                        返回 res 转为 任意  转为 迭代器结果_<U>;
                    }
                    常量 value = mapFn(res.value);
                    如果 (value !== 未定) {
                        返回 { value, done: 为假 };
                    }
                }
            }
        };
    }

    导出 常量 emptyIterator: 迭代器_<不及> = { next: () => ({ value: 未定 转为 不及, done: 为真 }) };

    导出 函数 singleIterator<T>(value: T): 迭代器_<T> {
        变量 done = 为假;
        返回 {
            next() {
                常量 wasDone = done;
                done = 为真;
                返回 wasDone ? { value: 未定 转为 不及, done: 为真 } : { value, done: 为假 };
            }
        };
    }

    /**
     * Computes the 首个 matching 跨度 of 元素组 and returns a tuple of the 首个 跨度
     * and the remaining 元素组.
     */
    导出 函数 跨度<T>(数组: 只读数组_<T>, f: (x: T, i: 数字) => 真假): [T[], T[]] {
        如果 (数组) {
            循环 (变量 i = 0; i < 数组.长度; i++) {
                如果 (!f(数组[i], i)) {
                    返回 [数组.分切(0, i), 数组.分切(i)];
                }
            }
            返回 [数组.分切(0), []];
        }

        返回 未定!;
    }

    /**
     * Maps contiguous spans of values with the same key.
     *
     * @param 数组 The 数组 to map.
     * @param keyfn A callback used to select the key for an 元素.
     * @param mapfn A callback used to map a contiguous chunk of values to a single value.
     */
    导出 函数 spanMap<T, K, U>(数组: 只读数组_<T>, keyfn: (x: T, i: 数字) => K, mapfn: (chunk: T[], key: K, 开始: 数字, 尾位: 数字) => U): U[] {
        变量 结果: U[];
        如果 (数组) {
            结果 = [];
            常量 len = 数组.长度;
            变量 previousKey: K;
            变量 key: K;
            变量 开始 = 0;
            变量 首位 = 0;
            判断 (开始 < len) {
                判断 (首位 < len) {
                    常量 value = 数组[首位];
                    key = keyfn(value, 首位);
                    如果 (首位 === 0) {
                        previousKey = key;
                    }
                    否则 如果 (key !== previousKey!) {
                        跳出;
                    }

                    首位++;
                }

                如果 (开始 < 首位) {
                    常量 v = mapfn(数组.分切(开始, 首位), previousKey, 开始, 首位);
                    如果 (v) {
                        结果.压入(v);
                    }

                    开始 = 首位;
                }

                previousKey = key!;
                首位++;
            }
        }

        返回 结果!;
    }

    导出 函数 mapEntries<T, U>(map: 词典_<T>, f: (key: 文字, value: T) => [文字, U]): 词典_<U> {
        如果 (!map) {
            返回 未定!;
        }

        常量 结果 = 创建词典<U>();
        map.循环执行((value, key) => {
            常量 [newKey, newValue] = f(key, value);
            结果.设置(newKey, newValue);
        });
        返回 结果;
    }

    导出 函数 某些<T>(数组: 只读数组_<T> | 未定, predicate?: (value: T) => 真假): 真假 {
        如果 (数组) {
            如果 (predicate) {
                循环 (常量 v 属于 数组) {
                    如果 (predicate(v)) {
                        返回 为真;
                    }
                }
            }
            否则 {
                返回 数组.长度 > 0;
            }
        }
        返回 为假;
    }

    导出 函数 组合<T>(array1: T[], array2: T[]): T[];
    导出 函数 组合<T>(array1: 只读数组_<T>, array2: 只读数组_<T>): 只读数组_<T>;
    导出 函数 组合<T>(array1: T[], array2: T[]): T[] {
        如果 (!某些(array2)) 返回 array1;
        如果 (!某些(array1)) 返回 array2;
        返回 [...array1, ...array2];
    }

    函数 deduplicateRelational<T>(数组: 只读数组_<T>, equalityComparer: 相等比较器_<T>, comparer: 比较器_<T>) {
        // Perform a stable sort of the 数组. This ensures the 首个 entry in a 列表 of
        // duplicates remains the 首个 entry in the 结果.
        常量 indices = 数组.映射((_, i) => i);
        stableSortIndices(数组, indices, comparer);

        变量 最后的 = 数组[indices[0]];
        常量 deduplicated: 数字[] = [indices[0]];
        循环 (变量 i = 1; i < indices.长度; i++) {
            常量 index = indices[i];
            常量 item = 数组[index];
            如果 (!equalityComparer(最后的, item)) {
                deduplicated.压入(index);
                最后的 = item;
            }
        }

        // restore 原始 order
        deduplicated.排序();
        返回 deduplicated.映射(i => 数组[i]);
    }

    函数 deduplicateEquality<T>(数组: 只读数组_<T>, equalityComparer: 相等比较器_<T>) {
        常量 结果: T[] = [];
        循环 (常量 item 属于 数组) {
            pushIfUnique(结果, item, equalityComparer);
        }
        返回 结果;
    }

    /**
     * Deduplicates an unsorted 数组.
     * @param equalityComparer An optional `相等比较器_` used to determine if two values are duplicates.
     * @param comparer An optional `比较器_` used to sort entries before comparison, though the
     * 结果 will remain in the 原始 order in `数组`.
     */
    导出 函数 消除重复<T>(数组: 只读数组_<T>, equalityComparer: 相等比较器_<T>, comparer?: 比较器_<T>): T[]| 未定 {
        返回 !数组 ? 未定 :
            数组.长度 === 0 ? [] :
            数组.长度 === 1 ? 数组.分切() :
            comparer ? deduplicateRelational(数组, equalityComparer, comparer) :
            deduplicateEquality(数组, equalityComparer);
    }

    /**
     * Deduplicates an 数组 that has already been sorted.
     */
    函数 deduplicateSorted<T>(数组: 只读数组_<T>, comparer: 相等比较器_<T> | 比较器_<T>) {
        如果 (!数组) 返回 未定;
        如果 (数组.长度 === 0) 返回 [];

        变量 最后的 = 数组[0];
        常量 deduplicated: T[] = [最后的];
        循环 (变量 i = 1; i < 数组.长度; i++) {
            常量 next = 数组[i];
            假如 (comparer(next, 最后的)) {
                // equality comparison
                若是 为真:

                // relational comparison
                若是 比较结果_.等于_:
                    继续;

                若是 比较结果_.小于_:
                    // If `数组` is sorted, `next` should **never** be less than `最后的`.
                    返回 调试_.失败('Array is unsorted.');
            }

            deduplicated.压入(最后的 = next);
        }

        返回 deduplicated;
    }

    导出 函数 插入排序<T>(数组: 排序数组_<T>, insert: T, compare: 比较器_<T>): 无值 {
        如果 (数组.长度 === 0) {
            数组.压入(insert);
            返回;
        }

        常量 insertIndex = 二分搜索(数组, insert, 身份, compare);
        如果 (insertIndex < 0) {
            数组.分离(~insertIndex, 0, insert);
        }
    }

    导出 函数 sortAndDeduplicate<T>(数组: 只读数组_<T>, comparer: 比较器_<T>, equalityComparer?: 相等比较器_<T>) {
        返回 deduplicateSorted(排序(数组, comparer), equalityComparer || comparer);
    }

    导出 函数 数组是相等的<T>(array1: 只读数组_<T> | 未定, array2: 只读数组_<T> | 未定, 相等比较器: (a: T, b: T) => 真假 = 相等值): 真假 {
        如果 (!array1 || !array2) {
            返回 array1 === array2;
        }

        如果 (array1.长度 !== array2.长度) {
            返回 为假;
        }

        循环 (变量 i = 0; i < array1.长度; i++) {
            如果 (!相等比较器(array1[i], array2[i])) {
                返回 为假;
            }
        }

        返回 为真;
    }

    /**
     * Compacts an 数组, removing any falsey 元素组.
     */
    导出 函数 compact<T>(数组: T[]): T[];
    导出 函数 compact<T>(数组: 只读数组_<T>): 只读数组_<T>;
    导出 函数 compact<T>(数组: T[]): T[] {
        变量 结果: T[];
        如果 (数组) {
            循环 (变量 i = 0; i < 数组.长度; i++) {
                常量 v = 数组[i];
                如果 (结果! || !v) {
                    如果 (!结果) {
                        结果 = 数组.分切(0, i);
                    }
                    如果 (v) {
                        结果.压入(v);
                    }
                }
            }
        }
        返回 结果! || 数组;
    }

    /**
     * Gets the relative complement of `arrayA` with respect to `arrayB`, returning the 元素组 that
     * are not present in `arrayA` but are present in `arrayB`. Assumes both arrays are sorted
     * based on the provided comparer.
     */
    导出 函数 relativeComplement<T>(arrayA: T[] | 未定, arrayB: T[] | 未定, comparer: 比较器_<T>): T[] | 未定 {
        如果 (!arrayB || !arrayA || arrayB.长度 === 0 || arrayA.长度 === 0) 返回 arrayB;
        常量 结果: T[] = [];
        loopB: 循环 (变量 offsetA = 0, offsetB = 0; offsetB < arrayB.长度; offsetB++) {
            如果 (offsetB > 0) {
                // Ensure `arrayB` is properly sorted.
                调试_.断言大于或等于(comparer(arrayB[offsetB], arrayB[offsetB - 1]), 比较结果_.等于_);
            }

            loopA: 循环 (常量 startA = offsetA; offsetA < arrayA.长度; offsetA++) {
                如果 (offsetA > startA) {
                    // Ensure `arrayA` is properly sorted. We only need to perform this check if
                    // `offsetA` has changed since we entered the loop.
                    调试_.断言大于或等于(comparer(arrayA[offsetA], arrayA[offsetA - 1]), 比较结果_.等于_);
                }

                假如 (comparer(arrayB[offsetB], arrayA[offsetA])) {
                    若是 比较结果_.小于_:
                        // If B is less than A, B does not exist in arrayA. Add B to the 结果 and
                        // move to the next 元素 in arrayB without changing the 当前 position
                        // in arrayA.
                        结果.压入(arrayB[offsetB]);
                        继续 loopB;
                    若是 比较结果_.等于_:
                        // If B is equal to A, B exists in arrayA. Move to the next 元素 in
                        // arrayB without adding B to the 结果 or changing the 当前 position
                        // in arrayA.
                        继续 loopB;
                    若是 比较结果_.大于_:
                        // If B is greater than A, we need to keep looking for B in arrayA. Move to
                        // the next 元素 in arrayA and recheck.
                        继续 loopA;
                }
            }
        }
        返回 结果;
    }

    导出 函数 sum<T 扩展 记录_<K, 数字>, K 扩展 文字>(数组: 只读数组_<T>, 属性: K): 数字 {
        变量 结果 = 0;
        循环 (常量 v 属于 数组) {
            // TODO: Remove the following 类型 assertion once the fix for #17069 is merged
            结果 += v[属性] 转为 数字;
        }
        返回 结果;
    }

    /**
     * Appends a value to an 数组, returning the 数组.
     *
     * @param to The 数组 to which `value` is to be appended. If `to` is `未定`, a new 数组
     * is created if `value` was appended.
     * @param value The value to 追加 to the 数组. If `value` is `未定`, nothing is
     * appended.
     */
    导出 函数 追加<T>(to: T[] | 未定, value: T | 未定): T[] | 未定 {
        如果 (value === 未定) 返回 to;
        如果 (to === 未定) 返回 [value];
        to.压入(value);
        返回 to;
    }

    /**
     * Gets the actual offset into an 数组 for a relative offset. Negative offsets indicate a
     * position offset from the 尾位 of the 数组.
     */
    函数 toOffset(数组: 只读数组_<任意>, offset: 数字) {
        返回 offset < 0 ? 数组.长度 + offset : offset;
    }

    /**
     * Appends a range of value to an 数组, returning the 数组.
     *
     * @param to The 数组 to which `value` is to be appended. If `to` is `未定`, a new 数组
     * is created if `value` was appended.
     * @param from The values to 追加 to the 数组. If `from` is `未定`, nothing is
     * appended. If an 元素 of `from` is `未定`, that 元素 is not appended.
     * @param 开始 The offset in `from` at which to 开始 copying values.
     * @param 尾位 The offset in `from` at which to stop copying values (non-inclusive).
     */
    导出 函数 添加范围<T>(to: T[] | 未定, from: 只读数组_<T> | 未定, 开始?: 数字, 尾位?: 数字): T[] | 未定 {
        如果 (from === 未定 || from.长度 === 0) 返回 to;
        如果 (to === 未定) 返回 from.分切(开始, 尾位);
        开始 = 开始 === 未定 ? 0 : toOffset(from, 开始);
        尾位 = 尾位 === 未定 ? from.长度 : toOffset(from, 尾位);
        循环 (变量 i = 开始; i < 尾位 && i < from.长度; i++) {
            如果 (from[i] !== 未定) {
                to.压入(from[i]);
            }
        }
        返回 to;
    }

    /**
     * @return Whether the value was added.
     */
    导出 函数 pushIfUnique<T>(数组: T[], toAdd: T, equalityComparer?: 相等比较器_<T>): 真假 {
        如果 (包含(数组, toAdd, equalityComparer)) {
            返回 为假;
        }
        否则 {
            数组.压入(toAdd);
            返回 为真;
        }
    }

    /**
     * Unlike `pushIfUnique`, this can take `未定` as an input, and returns a new 数组.
     */
    导出 函数 附加如果唯一<T>(数组: T[] | 未定, toAdd: T, equalityComparer?: 相等比较器_<T>): T[] {
        如果 (数组) {
            pushIfUnique(数组, toAdd, equalityComparer);
            返回 数组;
        }
        否则 {
            返回 [toAdd];
        }
    }

    函数 stableSortIndices<T>(数组: 只读数组_<T>, indices: 数字[], comparer: 比较器_<T>) {
        // sort indices by value then position
        indices.排序((x, y) => comparer(数组[x], 数组[y]) || 比较值(x, y));
    }

    /**
     * Returns a new sorted 数组.
     */
    导出 函数 排序<T>(数组: 只读数组_<T>, comparer: 比较器_<T>) {
        返回 数组.分切().排序(comparer);
    }

    导出 函数 best<T>(iter: 迭代器_<T>, isBetter: (a: T, b: T) => 真假): T | 未定 {
        常量 x = iter.next();
        如果 (x.done) {
            返回 未定;
        }
        变量 best = x.value;
        判断 (为真) {
            常量 { value, done } = iter.next();
            如果 (done) {
                返回 best;
            }
            如果 (isBetter(value, best)) {
                best = value;
            }
        }
    }

    导出 函数 arrayIterator<T>(数组: 只读数组_<T>): 迭代器_<T> {
        变量 i = 0;
        返回 { 
            next: () => {
            如果 (i === 数组.长度) {
                返回 { value: 未定 转为 不及, done: 为真 };
            }
            否则 {
                i++;
                返回 { value: 数组[i - 1], done: 为假 };
            }
        }};
    }

    /**
     * Stable sort of an 数组. Elements equal to each other maintain their relative position in the 数组.
     */
    导出 函数 stableSort<T>(数组: 只读数组_<T>, comparer: 比较器_<T>) {
        常量 indices = 数组.映射((_, i) => i);
        stableSortIndices(数组, indices, comparer);
        返回 indices.映射(i => 数组[i]);
    }

    导出 函数 rangeEquals<T>(array1: 只读数组_<T>, array2: 只读数组_<T>, 首位: 数字, 尾位: 数字) {
        判断 (首位 < 尾位) {
            如果 (array1[首位] !== array2[首位]) {
                返回 为假;
            }
            首位++;
        }
        返回 为真;
    }

    /**
     * Returns the 元素 at a specific offset in an 数组 if non-empty, `未定` otherwise.
     * A 消极的 offset indicates the 元素 should be retrieved from the 尾位 of the 数组.
     */
    导出 函数 elementAt<T>(数组: 只读数组_<T> | 未定, offset: 数字): T | 未定 {
        如果 (数组) {
            offset = toOffset(数组, offset);
            如果 (offset < 数组.长度) {
                返回 数组[offset];
            }
        }
        返回 未定;
    }

    /**
     * Returns the 首个 元素 of an 数组 if non-empty, `未定` otherwise.
     */
    导出 函数 firstOrUndefined<T>(数组: 只读数组_<T>): T | 未定 {
        返回 elementAt(数组, 0);
    }

    导出 函数 首个<T>(数组: 只读数组_<T>): T {
        调试_.断言(数组.长度 !== 0);
        返回 数组[0];
    }

    /**
     * Returns the 最后的 元素 of an 数组 if non-empty, `未定` otherwise.
     */
    导出 函数 最后或未定义<T>(数组: 只读数组_<T>): T | 未定 {
        返回 elementAt(数组, -1);
    }

    导出 函数 最后的<T>(数组: 只读数组_<T>): T {
        调试_.断言(数组.长度 !== 0);
        返回 数组[数组.长度 - 1];
    }

    /**
     * Returns the only 元素 of an 数组 if it contains only one 元素, `未定` otherwise.
     */
    导出 函数 singleOrUndefined<T>(数组: 只读数组_<T>): T | 未定 {
        返回 数组 && 数组.长度 === 1
            ? 数组[0]
            : 未定;
    }

    /**
     * Returns the only 元素 of an 数组 if it contains only one 元素; otheriwse, returns the
     * 数组.
     */
    导出 函数 singleOrMany<T>(数组: T[]): T | T[];
    导出 函数 singleOrMany<T>(数组: 只读数组_<T>): T | 只读数组_<T>;
    导出 函数 singleOrMany<T>(数组: T[]): T | T[] {
        返回 数组 && 数组.长度 === 1
            ? 数组[0]
            : 数组;
    }

    导出 函数 replaceElement<T>(数组: 只读数组_<T>, index: 数字, value: T): T[] {
        常量 结果 = 数组.分切(0);
        结果[index] = value;
        返回 结果;
    }

    /**
     * Performs a binary search, finding the index at which `value` occurs in `数组`.
     * If no such index is found, returns the 2's-complement of 首个 index at which
     * `数组[index]` exceeds `value`.
     * @param 数组 A sorted 数组 whose 首个 元素 must be no larger than number
     * @param value The value to be searched for in the 数组.
     * @param keySelector A callback used to select the search key from `value` and each 元素 of
     * `数组`.
     * @param keyComparer A callback used to compare two keys in a sorted 数组.
     * @param offset An offset into `数组` at which to 开始 the search.
     */
    导出 函数 二分搜索<T, U>(数组: 只读数组_<T>, value: T, keySelector: (v: T) => U, keyComparer: 比较器_<U>, offset?: 数字): 数字 {
        如果 (!数组 || 数组.长度 === 0) {
            返回 -1;
        }

        变量 low = offset || 0;
        变量 high = 数组.长度 - 1;
        常量 key = keySelector(value);
        判断 (low <= high) {
            常量 middle = low + ((high - low) >> 1);
            常量 midKey = keySelector(数组[middle]);
            假如 (keyComparer(midKey, key)) {
                若是 比较结果_.小于_:
                    low = middle + 1;
                    跳出;
                若是 比较结果_.等于_:
                    返回 middle;
                若是 比较结果_.大于_:
                    high = middle - 1;
                    跳出;
            }
        }

        返回 ~low;
    }

    导出 函数 reduceLeft<T, U>(数组: 只读数组_<T>, f: (memo: U, value: T, i: 数字) => U, initial: U, 开始?: 数字, count?: 数字): U;
    导出 函数 reduceLeft<T>(数组: 只读数组_<T>, f: (memo: T, value: T, i: 数字) => T): T;
    导出 函数 reduceLeft<T>(数组: T[], f: (memo: T, value: T, i: 数字) => T, initial?: T, 开始?: 数字, count?: 数字): T {
        如果 (数组 && 数组.长度 > 0) {
            常量 size = 数组.长度;
            如果 (size > 0) {
                变量 首位 = 开始 === 未定 || 开始 < 0 ? 0 : 开始;
                常量 尾位 = count === 未定 || 首位 + count > size - 1 ? size - 1 : 首位 + count;
                变量 结果: T;
                如果 (arguments.长度 <= 2) {
                    结果 = 数组[首位];
                    首位++;
                }
                否则 {
                    结果 = initial!;
                }
                判断 (首位 <= 尾位) {
                    结果 = f(结果, 数组[首位], 首位);
                    首位++;
                }
                返回 结果;
            }
        }
        返回 initial!;
    }

    导出 常量 hasOwnProperty = 实例_.原型.具有本身属性;

    /**
     * Indicates whether a map-like contains an own property with the specified key.
     *
     * @param map A map-like.
     * @param key A property key.
     */
    导出 函数 具有属性(map: 词典族_<任意>, key: 文字): 真假 {
        返回 hasOwnProperty.调用(map, key);
    }

    /**
     * Gets the value of an owned property in a map-like.
     *
     * @param map A map-like.
     * @param key A property key.
     */
    导出 函数 getProperty<T>(map: 词典族_<T>, key: 文字): T | 未定 {
        返回 hasOwnProperty.调用(map, key) ? map[key] : 未定;
    }

    /**
     * Gets the owned, enumerable property keys of a map-like.
     */
    导出 函数 getOwnKeys<T>(map: 词典族_<T>): 文字[] {
        常量 keys: 文字[] = [];
        循环 (常量 key 位于 map) {
            如果 (hasOwnProperty.调用(map, key)) {
                keys.压入(key);
            }
        }

        返回 keys;
    }

    导出 函数 getOwnValues<T>(sparseArray: T[]): T[] {
        常量 values: T[] = [];
        循环 (常量 key 位于 sparseArray) {
            如果 (hasOwnProperty.调用(sparseArray, key)) {
                values.压入(sparseArray[key]);
            }
        }

        返回 values;
    }

    /** Shims `Array.from`. */
    导出 函数 数组从<T, U>(iterator: 迭代器_<T>, map: (t: T) => U): U[];
    导出 函数 数组从<T>(iterator: 迭代器_<T>): T[];
    导出 函数 数组从(iterator: 迭代器_<任意>, map?: (t: 任意) => 任意): 任意[] {
        常量 结果: 任意[] = [];
        循环 (变量 { value, done } = iterator.next(); !done; { value, done } = iterator.next()) {
            结果.压入(map ? map(value) : value);
        }
        返回 结果;
    }

    /**
     * Calls `callback` for each entry in the map, returning the 首个 truthy 结果.
     * Use `map.forEach` instead for normal iteration.
     */
    导出 函数 循环每个<T, U>(map: 词典_<T>, callback: (value: T, key: 文字) => U | 未定): U | 未定;
    导出 函数 循环每个<T, U>(map: 词典_<T>, callback: (value: T, key: 文字) => U | 未定): U | 未定;
    导出 函数 循环每个<T, U>(map: 词典_<T> | 词典_<T>, callback: (value: T, key: 文字 ) => U | 未定): U | 未定 {
        常量 iterator = map.条目组();
        循环 (变量 { value: pair, done } = iterator.next(); !done; { value: pair, done } = iterator.next()) {
            常量 [key, value] = pair;
            常量 结果 = callback(value, key 转为 (文字 & 文字));
            如果 (结果) {
                返回 结果;
            }
        }
        返回 未定;
    }

    /** `forEachEntry` for just keys. */
    导出 函数 循环每个键<T>(map: 词典_<{}>, callback: (key: 文字) => T | 未定): T | 未定;
    导出 函数 循环每个键<T>(map: 词典_<{}>, callback: (key: 文字) => T | 未定): T | 未定;
    导出 函数 循环每个键<T>(map: 词典_<{}> | 词典_<{}>, callback: (key: 文字 & 文字) => T | 未定): T | 未定 {
        常量 iterator = map.键组();
        循环 (变量 { value: key, done } = iterator.next(); !done; { value: key, done } = iterator.next()) {
            常量 结果 = callback(key 转为 文字 & 文字);
            如果 (结果) {
                返回 结果;
            }
        }
        返回 未定;
    }

    /** Copy entries from `source` to `目标`. */
    导出 函数 复制条目<T>(source: 词典_<T>, 目标: 词典_<T>): 无值;
    导出 函数 复制条目<T>(source: 词典_<T>, 目标: 词典_<T>): 无值;
    导出 函数 复制条目<T, U 扩展 词典_<T> | 词典_<T>>(source: U, 目标: U): 无值 {
        (source 转为 词典_<T>).循环执行((value, key) => {
            (目标 转为 词典_<T>).设置(key, value);
        });
    }

    导出 函数 assign<T1 扩展 词典族_<{}>, T2, T3>(t: T1, 参数1: T2, 参数2: T3): T1 & T2 & T3;
    导出 函数 assign<T1 扩展 词典族_<{}>, T2>(t: T1, 参数1: T2): T1 & T2;
    导出 函数 assign<T1 扩展 词典族_<{}>>(t: T1, ...args: 任意[]): 任意;
    导出 函数 assign<T1 扩展 词典族_<{}>>(t: T1, ...args: 任意[]) {
        循环 (常量 arg 属于 args) {
            循环 (常量 p 位于 arg) {
                如果 (具有属性(arg, p)) {
                    t[p] = arg[p];
                }
            }
        }
        返回 t;
    }

    /**
     * Performs a shallow equality comparison of the contents of two map-likes.
     *
     * @param 左侧 A map-like whose 属性组 should be compared.
     * @param 右侧 A map-like whose 属性组 should be compared.
     */
    导出 函数 自身属性相等<T>(左侧: 词典族_<T>, 右侧: 词典族_<T>, 相等比较器: 相等比较器_<T> = 相等值) {
        如果 (左侧 === 右侧) 返回 为真;
        如果 (!左侧 || !右侧) 返回 为假;
        循环 (常量 key 位于 左侧) {
            如果 (hasOwnProperty.调用(左侧, key)) {
                如果 (!hasOwnProperty.调用(右侧, key) === 未定) 返回 为假;
                如果 (!相等比较器(左侧[key], 右侧[key])) 返回 为假;
            }
        }

        循环 (常量 key 位于 右侧) {
            如果 (hasOwnProperty.调用(右侧, key)) {
                如果 (!hasOwnProperty.调用(左侧, key)) 返回 为假;
            }
        }

        返回 为真;
    }

    /**
     * Creates a map from the 元素组 of an 数组.
     *
     * @param 数组 the 数组 of input 元素组.
     * @param 生成键 a function that produces a key for a given 元素.
     *
     * This function makes no effort to avoid collisions; if any two 元素组 produce
     * the same key with the given 'makeKey' function, then the 元素 with the higher
     * index in the 数组 will be the one associated with the produced key.
     */
    导出 函数 转为词典<T>(数组: 只读数组_<T>, 生成键: (值: T) => 文字): 词典_<T>;
    导出 函数 转为词典<T, U>(数组: 只读数组_<T>, 生成键: (值: T) => 文字, 生成值: (值: T) => U): 词典_<U>;
    导出 函数 转为词典<T, U>(数组: 只读数组_<T>, 生成键: (值: T) => 文字, 生成值: (值: T) => T | U = 身份): 词典_<T | U> {
        常量 结果 = 创建词典<T | U>();
        循环 (常量 值 属于 数组) {
            结果.设置(生成键(值), 生成值(值));
        }
        返回 结果;
    }

    导出 函数 数字到数字下标词典<T>(数组: 只读数组_<T>, 生成键: (值: T) => 数字): T[];
    导出 函数 数字到数字下标词典<T, U>(数组: 只读数组_<T>, 生成键: (值: T) => 数字, 生成值: (值: T) => U): U[];
    导出 函数 数字到数字下标词典<T, U>(数组: 只读数组_<T>, 生成键: (值: T) => 数字, 生成值: (值: T) => T | U = 身份): (T | U)[] {
        常量 结果: (T | U)[] = [];
        循环 (常量 值 属于 数组) {
            结果[生成键(值)] = 生成值(值);
        }
        返回 结果;
    }

    /**
     * Creates a set from the 元素组 of an 数组.
     *
     * @param 数组 the 数组 of input 元素组.
     */
    导出 函数 数组转为集合(数组: 只读数组_<文字>): 词典_<为真>;
    导出 函数 数组转为集合<T>(数组: 只读数组_<T>, 生成键: (值: T) => 文字): 词典_<为真>;
    导出 函数 数组转为集合(数组: 只读数组_<任意>, 生成键?: (值: 任意) => 文字): 词典_<为真> {
        返回 转为词典<任意, 为真>(数组, 生成键 || (s => s), () => 为真);
    }

    导出 函数 数字到多行词典<T>(值组: 只读数组_<T>, 生成键: (值: T) => 文字): 多行词典_<T>;
    导出 函数 数字到多行词典<T, U>(值组: 只读数组_<T>, 生成键: (值: T) => 文字, 生成值: (值: T) => U): 多行词典_<U>;
    导出 函数 数字到多行词典<T, U>(值组: 只读数组_<T>, 生成键: (值: T) => 文字, 生成值: (值: T) => T | U = 身份): 多行词典_<T | U> {
        常量 结果 = 创建多维词典<T | U>();
        循环 (常量 值 属于 值组) {
            结果.添加(生成键(值), 生成值(值));
        }
        返回 结果;
    }

    导出 函数 集团<T>(值组: 只读数组_<T>, 获取集团Id: (值: T) => 文字): 只读数组_<只读数组_<T>> {
        返回 数组从(数字到多行词典(值组, 获取集团Id).值组());
    }

    导出 函数 克隆<T>(object: T): T {
        常量 结果: 任意 = {};
        循环 (常量 id 位于 object) {
            如果 (hasOwnProperty.调用(object, id)) {
                结果[id] = (<任意>object)[id];
            }
        }
        返回 结果;
    }

    导出 函数 展开<T1, T2>(首个: T1, 第二个: T2): T1 & T2 {
        常量 结果: T1 & T2 = <任意>{};
        循环 (常量 id 位于 第二个) {
            如果 (hasOwnProperty.调用(第二个, id)) {
                (结果 转为 任意)[id] = (第二个 转为 任意)[id];
            }
        }

        循环 (常量 id 位于 首个) {
            如果 (hasOwnProperty.调用(首个, id)) {
                (结果 转为 任意)[id] = (首个 转为 任意)[id];
            }
        }

        返回 结果;
    }

    导出 接口 多行词典_<T> 扩展 词典_<T[]> {
        /**
         * Adds the value to an 数组 of values associated with the key, and returns the 数组.
         * Creates the 数组 if it does not already exist.
         */
        添加(key: 文字, value: T): T[];
        /**
         * Removes a value from an 数组 of values associated with the key.
         * Does not preserve the order of those values.
         * Does nothing if `key` is not in `map`, or `value` is not in `map[key]`.
         */
        移除(key: 文字, value: T): 无值;
    }

    导出 函数 创建多维词典<T>(): 多行词典_<T> {
        常量 map = 创建词典<T[]>() 转为 多行词典_<T>;
        map.添加 = 多维添加;
        map.移除 = 多行删除;
        返回 map;
    }

    函数 多维添加<T>(this: 多行词典_<T>, key: 文字, value: T) {
        变量 values = 本体.获取(key);
        如果 (values) {
            values.压入(value);
        }
        否则 {
            本体.设置(key, values = [value]);
        }
        返回 values;
    }

    函数 多行删除<T>(this: 多行词典_<T>, key: 文字, value: T) {
        常量 values = 本体.获取(key);
        如果 (values) {
            无序移除项目(values, value);
            如果 (!values.长度) {
                本体.删除(key);
            }
        }
    }

    /**
     * Tests whether a value is an 数组.
     */
    导出 函数 是数组(value: 任意): value 作为 只读数组_<{}> {
        返回 数组_.是数组 ? 数组_.是数组(value) : value 身为 数组_;
    }

    导出 函数 转为数组<T>(value: T | T[]): T[];
    导出 函数 转为数组<T>(value: T | 只读数组_<T>): 只读数组_<T>;
    导出 函数 转为数组<T>(value: T | T[]): T[] {
        返回 是数组(value) ? value : [value];
    }

    /**
     * Tests whether a value is string
     */
    导出 函数 是文字(文本: 任意): 文本 作为 文字 {
        返回 类为 文本 === 'string';
    }

    导出 函数 tryCast<TOut 扩展 TIn, TIn = 任意>(value: TIn | 未定, test: (value: TIn) => value 作为 TOut): TOut | 未定 {
        返回 value !== 未定 && test(value) ? value : 未定;
    }

    /** Does nothing. */
    导出 函数 什么都不做(_?: {} | 空值 | 未定): 无值 { } // tslint:disable-line no-empty

    /** Do nothing and return false */
    导出 函数 返回假(): 为假 { 返回 为假; }

    /** Do nothing and return true */
    导出 函数 返回真(): 为真 { 返回 为真; }

    /** Returns its argument. */
    导出 函数 身份<T>(x: T) { 返回 x; }

    /** Returns lower case string */
    导出 函数 转为小写(x: 文字) { 返回 x.转为小写(); }

    /** Throws an error because a function is not implemented. */
    导出 函数 未实现(): 不及 {
        抛出 新建 错误_('Not implemented');
    }

    导出 函数 记忆<T>(回调: () => T): () => T {
        变量 值: T;
        返回 () => {
            如果 (回调) {
                值 = 回调();
                回调 = 未定!;
            }
            返回 值;
        };
    }

    /**
     * High-order function, creates a function that executes a function composition.
     * For example, `chain(a, b)` is the equivalent of `x => ((a', b') => y => b'(a'(y)))(a(x), b(x))`
     *
     * @param args The functions to chain.
     */
    导出 函数 链调用<T, U>(...args: ((t: T) => (u: U) => U)[]): (t: T) => (u: U) => U;
    导出 函数 链调用<T, U>(a: (t: T) => (u: U) => U, b: (t: T) => (u: U) => U, c: (t: T) => (u: U) => U, d: (t: T) => (u: U) => U, e: (t: T) => (u: U) => U): (t: T) => (u: U) => U {
        如果 (e) {
            常量 args: ((t: T) => (u: U) => U)[] = [];
            循环 (变量 i = 0; i < arguments.长度; i++) {
                args[i] = arguments[i];
            }

            返回 t => 组合起来(...词典(args, f => f(t)));
        }
        否则 如果 (d) {
            返回 t => 组合起来(a(t), b(t), c(t), d(t));
        }
        否则 如果 (c) {
            返回 t => 组合起来(a(t), b(t), c(t));
        }
        否则 如果 (b) {
            返回 t => 组合起来(a(t), b(t));
        }
        否则 如果 (a) {
            返回 t => 组合起来(a(t));
        }
        否则 {
            返回 _ => u => u;
        }
    }

    /**
     * High-order function, composes functions. Note that functions are composed inside-out;
     * for example, `compose(a, b)` is the equivalent of `x => b(a(x))`.
     *
     * @param args The functions to compose.
     */
    导出 函数 组合起来<T>(...args: ((t: T) => T)[]): (t: T) => T;
    导出 函数 组合起来<T>(a: (t: T) => T, b: (t: T) => T, c: (t: T) => T, d: (t: T) => T, e: (t: T) => T): (t: T) => T {
        如果 (e) {
            常量 args: ((t: T) => T)[] = [];
            循环 (变量 i = 0; i < arguments.长度; i++) {
                args[i] = arguments[i];
            }

            返回 t => reduceLeft(args, (u, f) => f(u), t);
        }
        否则 如果 (d) {
            返回 t => d(c(b(a(t))));
        }
        否则 如果 (c) {
            返回 t => c(b(a(t)));
        }
        否则 如果 (b) {
            返回 t => b(a(t));
        }
        否则 如果 (a) {
            返回 t => a(t);
        }
        否则 {
            返回 t => t;
        }
    }

    导出 函数 格式化文字从参数(文本: 文字, args: { [index: 数字]: 文字; }, baseIndex?: 数字): 文字 {
        baseIndex = baseIndex || 0;

        返回 文本.替换(/{(\d+)}/g, (_match, index?) => args[+index + baseIndex!]);
    }

    导出 函数 相等值<T>(a: T, b: T) {
        返回 a === b;
    }

    /**
     * Compare the equality of two strings using a case-sensitive ordinal comparison.
     *
     * Case-sensitive comparisons compare both strings one code-point at a time using the integer
     * value of each code-point after applying `toUpperCase` to each string. We always map both
     * strings to their upper-case form as some unicode characters do not properly round-trip to
     * lowercase (such as `ẞ` (German sharp capital s)).
     */
    导出 函数 相等文字不区分大小写(a: 文字, b: 文字) {
        返回 a === b
            || a !== 未定
            && b !== 未定
            && a.转为大写() === b.转为大写();
    }

    /**
     * Compare the equality of two strings using a case-sensitive ordinal comparison.
     *
     * Case-sensitive comparisons compare both strings one code-point at a time using the
     * integer value of each code-point.
     */
    导出 函数 相等文字区分大小写(a: 文字, b: 文字) {
        返回 相等值(a, b);
    }

    函数 比较可比较值(a: 文字, b: 文字): 比较结果_;
    函数 比较可比较值(a: 数字, b: 数字): 比较结果_;
    函数 比较可比较值(a: 文字 | 数字, b: 文字 | 数字) {
        返回 a === b ? 比较结果_.等于_ :
            a === 未定 ? 比较结果_.小于_ :
            b === 未定 ? 比较结果_.大于_ :
            a < b ? 比较结果_.小于_ :
            比较结果_.大于_;
    }

    /**
     * Compare two numeric values for their order relative to each other.
     * To compare strings, use any of the `compareStrings` functions.
     */
    导出 函数 比较值(a: 数字, b: 数字) {
        返回 比较可比较值(a, b);
    }

    /**
     * Compare two strings using a case-insensitive ordinal comparison.
     *
     * Ordinal comparisons are based on the difference between the unicode code points of both
     * strings. Characters with multiple unicode representations are considered unequal. Ordinal
     * comparisons provide predictable ordering, but place 'a' after 'B'.
     *
     * Case-insensitive comparisons compare both strings one code-point at a time using the integer
     * value of each code-point after applying `toUpperCase` to each string. We always map both
     * strings to their upper-case form as some unicode characters do not properly round-trip to
     * lowercase (such as `ẞ` (German sharp capital s)).
     */
    导出 函数 边距文字不区分大小写(a: 文字, b: 文字) {
        如果 (a === b) 返回 比较结果_.等于_;
        如果 (a === 未定) 返回 比较结果_.小于_;
        如果 (b === 未定) 返回 比较结果_.大于_;
        a = a.转为大写();
        b = b.转为大写();
        返回 a < b ? 比较结果_.小于_ : a > b ? 比较结果_.大于_ : 比较结果_.等于_;
    }

    /**
     * Compare two strings using a case-sensitive ordinal comparison.
     *
     * Ordinal comparisons are based on the difference between the unicode code points of both
     * strings. Characters with multiple unicode representations are considered unequal. Ordinal
     * comparisons provide predictable ordering, but place 'a' after 'B'.
     *
     * Case-sensitive comparisons compare both strings one code-point at a time using the integer
     * value of each code-point.
     */
    导出 函数 比较字符串区分大小写(a: 文字, b: 文字) {
        返回 比较可比较值(a, b);
    }

    /**
     * Creates a string comparer for use with string collation in the UI.
     */
    常量 创建UI文字比较器 = (() => {
        变量 defaultComparer: 比较器_<文字> | 未定;
        变量 enUSComparer: 比较器_<文字> | 未定;

        常量 stringComparerFactory = getStringComparerFactory();
        返回 createStringComparer;

        函数 compareWithCallback(a: 文字 | 未定, b: 文字 | 未定, comparer: (a: 文字, b: 文字) => 数字) {
            如果 (a === b) 返回 比较结果_.等于_;
            如果 (a === 未定) 返回 比较结果_.小于_;
            如果 (b === 未定) 返回 比较结果_.大于_;
            常量 value = comparer(a, b);
            返回 value < 0 ? 比较结果_.小于_ : value > 0 ? 比较结果_.大于_ : 比较结果_.等于_;
        }

        函数 createIntlCollatorStringComparer(locale: 文字 | 未定): 比较器_<文字> {
            // Intl.Collator.prototype.compare is bound to the collator. See NOTE in
            // http://www.ecma-international.org/ecma-402/2.0/#sec-Intl.Collator.prototype.compare
            常量 comparer = 新建 国际化_.排序器_(locale, { 使用的: 'sort', 灵敏度: 'variant' }).比较;
            返回 (a, b) => compareWithCallback(a, b, comparer);
        }

        函数 createLocaleCompareStringComparer(locale: 文字 | 未定): 比较器_<文字> {
            // if the locale is not the 默认 locale (`未定`), use the fallback comparer.
            如果 (locale !== 未定) 返回 createFallbackStringComparer();

            返回 (a, b) => compareWithCallback(a, b, compareStrings);

            函数 compareStrings(a: 文字, b: 文字) {
                返回 a.本地比较(b);
            }
        }

        函数 createFallbackStringComparer(): 比较器_<文字> {
            // An ordinal comparison puts 'A' after 'b', but for the UI we want 'A' before 'b'.
            // We 首个 sort case insensitively.  So 'Aaa' will come before 'baa'.
            // Then we sort case sensitively, so 'aaa' will come before 'Aaa'.
            //
            // For case insensitive comparisons we always map both strings to their
            // upper-case form as some unicode characters do not properly round-trip to
            // lowercase (such as `ẞ` (German sharp capital s)).
            返回 (a, b) => compareWithCallback(a, b, compareDictionaryOrder);

            函数 compareDictionaryOrder(a: 文字, b: 文字) {
                返回 compareStrings(a.转为大写(), b.转为大写()) || compareStrings(a, b);
            }

            函数 compareStrings(a: 文字, b: 文字) {
                返回 a < b ? 比较结果_.小于_ : a > b ? 比较结果_.大于_ : 比较结果_.等于_;
            }
        }

        函数 getStringComparerFactory() {
            // If the host supports Intl, we use it for comparisons using the 默认 locale.
            如果 (类为 国际化_ === 'object' && 类为 国际化_.排序器_ === 'function') {
                返回 createIntlCollatorStringComparer;
            }

            // If the host does not support Intl, we fall back to localeCompare.
            // localeCompare in 节点_ v0.10 is just an ordinal comparison, so don't use it.
            如果 (类为 文字_.原型.本地比较 === 'function' &&
                类为 文字_.原型.转为本地大写 === 'function' &&
                'a'.本地比较('B') < 0) {
                返回 createLocaleCompareStringComparer;
            }

            // Otherwise, fall back to ordinal comparison:
            返回 createFallbackStringComparer;
        }

        函数 createStringComparer(locale: 文字 | 未定) {
            // Hold onto common string comparers. This avoids constantly reallocating comparers during
            // tests.
            如果 (locale === 未定) {
                返回 defaultComparer || (defaultComparer = stringComparerFactory(locale));
            }
            否则 如果 (locale === 'en-US') {
                返回 enUSComparer || (enUSComparer = stringComparerFactory(locale));
            }
            否则 {
                返回 stringComparerFactory(locale);
            }
        }
    })();

    变量 uiComparerCaseSensitive: 比较器_<文字> | 未定;
    变量 uiLocale: 文字 | 未定;

    导出 函数 getUILocale() {
        返回 uiLocale;
    }

    导出 函数 setUILocale(value: 文字) {
        如果 (uiLocale !== value) {
            uiLocale = value;
            uiComparerCaseSensitive = 未定;
        }
    }

    /**
     * Compare two strings in a using the case-sensitive sort behavior of the UI locale.
     *
     * Ordering is not predictable between different host locales, but is best for displaying
     * ordered data for UI presentation. Characters with multiple unicode representations may
     * be considered equal.
     *
     * Case-sensitive comparisons compare strings that differ in base characters, or
     * accents/diacritic marks, or case as unequal.
     */
    导出 函数 compareStringsCaseSensitiveUI(a: 文字, b: 文字) {
        常量 comparer = uiComparerCaseSensitive || (uiComparerCaseSensitive = 创建UI文字比较器(uiLocale));
        返回 comparer(a, b);
    }

    导出 函数 compareProperties<T, K 扩展 键为 T>(a: T, b: T, key: K, comparer: 比较器_<T[K]>) {
        返回 a === b ? 比较结果_.等于_ :
            a === 未定 ? 比较结果_.小于_ :
            b === 未定 ? 比较结果_.大于_ :
            comparer(a[key], b[key]);
    }


    /** 真_ is greater than false. */
    导出 函数 compareBooleans(a: 真假, b: 真假): 比较结果_ {
        返回 比较值(a ? 1 : 0, b ? 1 : 0);
    }

    导出 函数 开始包含(str: 文字, 前缀: 文字): 真假 {
        返回 str.最后索引位于(前缀, 0) === 0;
    }

    导出 函数 移除前缀(str: 文字, 前缀: 文字): 文字 {
        返回 开始包含(str, 前缀) ? str.子文本(前缀.长度) : str;
    }

    导出 函数 尾部包括(str: 文字, 后缀: 文字): 真假 {
        常量 expectedPos = str.长度 - 后缀.长度;
        返回 expectedPos >= 0 && str.索引位于(后缀, expectedPos) === expectedPos;
    }

    导出 函数 removeSuffix(str: 文字, 后缀: 文字): 文字 {
        返回 尾部包括(str, 后缀) ? str.分切(0, str.长度 - 后缀.长度) : str;
    }

    导出 函数 文本包含(str: 文字, substring: 文字): 真假 {
        返回 str.索引位于(substring) !== -1;
    }

    导出 常量 枚举 断言等级_ {
        无_ = 0,
        普通_ = 1,
        积极_ = 2,
        最积极_ = 3,
    }

    /**
     * Safer version of `函数_` which should not be called.
     * Every function should be assignable to this, but this should not be assignable to every function.
     */
    导出 类型 AnyFunction = (...args: 不及[]) => 无值;

    导出 名域 调试_ {
        导出 变量 当前断言级别 = 断言等级_.无_;
        导出 变量 是调试中_ = 为假;

        导出 函数 应该断言(level: 断言等级_): 真假 {
            返回 当前断言级别 >= level;
        }

        导出 函数 断言(表达式: 真假, 消息?: 文字, verboseDebugInfo?: 文字 | (() => 文字), stackCrawlMark?: AnyFunction): 无值 {
            如果 (!表达式) {
                如果 (verboseDebugInfo) {
                    消息 += '\r\nVerbose 调试_ Information: ' + (类为 verboseDebugInfo === 'string' ? verboseDebugInfo : verboseDebugInfo());
                }
                失败(消息 ? '假_ 表达式: ' + 消息 : '假_ 表达式.', stackCrawlMark || 断言);
            }
        }

        导出 函数 assertEqual<T>(a: T, b: T, msg?: 文字, msg2?: 文字): 无值 {
            如果 (a !== b) {
                常量 消息 = msg ? msg2 ? `${msg} ${msg2}` : msg : '';
                失败(`Expected ${a} === ${b}. ${消息}`);
            }
        }

        导出 函数 assertLessThan(a: 数字, b: 数字, msg?: 文字): 无值 {
            如果 (a >= b) {
                失败(`Expected ${a} < ${b}. ${msg || ''}`);
            }
        }

        导出 函数 断言小于或等于(a: 数字, b: 数字): 无值 {
            如果 (a > b) {
                失败(`Expected ${a} <= ${b}`);
            }
        }

        导出 函数 断言大于或等于(a: 数字, b: 数字): 无值 {
            如果 (a < b) {
                失败(`Expected ${a} >= ${b}`);
            }
        }

        导出 函数 失败(消息?: 文字, stackCrawlMark?: AnyFunction): 不及 {
            调试;
            常量 e = 新建 错误_(消息 ? `调试_ Failure. ${消息}` : '调试_ Failure.');
            如果 ((<任意>错误_).captureStackTrace) {
                (<任意>错误_).captureStackTrace(e, stackCrawlMark || 失败);
            }
            抛出 e;
        }

        导出 函数 断言已定于<T>(value: T | 空值 | 未定, 消息?: 文字): T {
            断言(value !== 未定 && value !== 空值, 消息);
            返回 value!;
        }

        导出 函数 assertEachDefined<T, A 扩展 只读数组_<T>>(value: A, 消息: 文字): A {
            循环 (常量 v 属于 value) {
                断言已定于(v, 消息);
            }
            返回 value;
        }

        导出 函数 断言不及(member: 不及, 消息?: 文字, stackCrawlMark?: AnyFunction): 不及 {
            返回 失败(消息 || `Illegal value: ${member}`, stackCrawlMark || 断言不及);
        }

        导出 函数 getFunctionName(func: AnyFunction) {
            如果 (类为 func !== 'function') {
                返回 '';
            }
            否则 如果 (func.原型.hasOwnProperty('名称')) {
                返回 (<任意>func).名称;
            }
            否则 {
                常量 文本 = 函数_.原型.转为文字.调用(func);
                常量 match = /^函数\s+([\w\$]+)\s*\(/.执行代码(文本);
                返回 match ? match[1] : '';
            }
        }
    }

    导出 函数 and<T>(f: (arg: T) => 真假, g: (arg: T) => 真假) {
        返回 (arg: T) => f(arg) && g(arg);
    }

    导出 函数 or<T>(f: (arg: T) => 真假, g: (arg: T) => 真假) {
        返回 (arg: T) => f(arg) || g(arg);
    }

    导出 函数 断言类型不及(_: 不及): 无值 { } // tslint:disable-line no-empty

    导出 常量 空文件系统条目: 文件系统条目_ = {
        文件组: 空数组,
        目录组: 空数组
    };

    导出 函数 匹配文件(路径: 文字, 扩展名组: 只读数组_<文字>, 当前目录: 文字, 深度: 数字 | 未定, 获取文件系统条目: (路径: 文字) => 文件系统条目_): 文字[] {
        路径 = 正规化路径(路径);
        当前目录 = 正规化路径(当前目录);

        常量 patterns = { 基路径: [路径] };
        // Associate an array of results with each include regex. This keeps results in order of the 'include' order.
        // If there are no 'includes', then just put everything in results[0].
        常量 结果: 文字[][] =  [[]];

        循环 (常量 基路径 属于 patterns.基路径) {
            访问目录(基路径, 合并路径(当前目录, 基路径), 深度);
        }

        返回 扁平化<文字>(结果);

        函数 访问目录(路径: 文字, 绝对路径: 文字, 深度: 数字 | 未定) {
            常量 { 文件组, 目录组 } = 获取文件系统条目(路径);

            循环 (常量 当前 属于 排序(文件组, 比较字符串区分大小写)) {
                常量 名称 = 合并路径(路径, 当前);
                如果 (扩展名组 && !文件扩展是其一(名称, 扩展名组)) 继续;
                结果[0].push(名称);
            }

            如果 (深度 !== 未定) {
                深度--;
                如果 (深度 <= 0) {
                    返回;
                }
            }

            循环 (常量 当前的 属于 排序(目录组, 比较字符串区分大小写)) {
                常量 名称 = 合并路径(路径, 当前的);
                常量 绝对名称 = 合并路径(绝对路径, 当前的);
                访问目录(名称, 绝对名称, 深度);
            }
        }
    }

    导出 函数 singleElementArray<T>(t: T | 未定): T[] | 未定 {
        返回 t === 未定 ? 未定 : [t];
    }

    导出 函数 枚举插入和删除<T, U>(新项目组: 只读数组_<T>, 旧项目组: 只读数组_<U>, 比较: (a: T, b: U) => 比较结果_, 插入: (新项目: T) => 无值, 删除的: (旧项目: U) => 无值, 未改变的?: (旧项目: U, 新项目: T) => 无值) {
        未改变的 = 未改变的 || 什么都不做;
        变量 新索引 = 0;
        变量 旧索引 = 0;
        常量 新长度 = 新项目组.长度;
        常量 旧长度 = 旧项目组.长度;
        判断 (新索引 < 新长度 && 旧索引 < 旧长度) {
            常量 新项目 = 新项目组[新索引];
            常量 旧项目 = 旧项目组[旧索引];
            常量 比较结果 = 比较(新项目, 旧项目);
            如果 (比较结果 === 比较结果_.小于_) {
                插入(新项目);
                新索引++;
            }
            否则 如果 (比较结果 === 比较结果_.大于_) {
                删除的(旧项目);
                旧索引++;
            }
            否则 {
                未改变的(旧项目, 新项目);
                新索引++;
                旧索引++;
            }
        }
        判断 (新索引 < 新长度) {
            插入(新项目组[新索引++]);
        }
        判断 (旧索引 < 旧长度) {
            删除的(旧项目组[旧索引++]);
        }
    }
}
